home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Reference Guide / C-C++ Interactive Reference Guide.iso / c_ref / csource5 / 355_01 / slk1.exe / SHERLOCK / SL1.H < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-09  |  7.1 KB  |  293 lines
  1. /*
  2.     Header file for Sherlock version 1 of the Sherlock macros.
  3.  
  4.     source:  sl1.h
  5.     started: September 27, 1985
  6.     version:
  7.         1.1 February 16, 1989
  8.         1.5 August 3, 1989
  9.         1.6 April 17, 1990
  10.         1.7 June 15, 1991
  11.  
  12.  
  13.     PUBLIC DOMAIN SOFTWARE
  14.  
  15.     Sherlock, including the SPP, SDEL and SDIF programs, was placed in
  16.     the public domain on June 15, 1991, by its author,
  17.  
  18.         Edward K. Ream
  19.         166 North Prospect Ave.
  20.         Madison, WI 53705.
  21.         (608) 257-0802
  22.  
  23.     Sherlock may be used for any commercial or non-commercial purpose.
  24.  
  25.  
  26.     DISCLAIMER OF WARRANTIES
  27.  
  28.     Edward K. Ream (Ream) specifically disclaims all warranties,
  29.     expressed or implied, with respect to this computer software,
  30.     including but not limited to implied warranties of merchantability
  31.     and fitness for a particular purpose.  In no event shall Ream be
  32.     liable for any loss of profit or any commercial damage, including
  33.     but not limited to special, incidental consequential or other damages.
  34. */
  35.  
  36. #define SL_VERSION_NAME    "1.6"
  37.  
  38. /*
  39.     NOTE 1:    You must include this file (or sl.h) in every file that
  40.         contains any Sherlock macro.  Do NOT use this file unless your
  41.         compiler absolutely can not handle the definitions in sl.h.
  42.         (See sl.h for more details.)
  43.         
  44.     NOTE 2:    If you want the sherlock macros to be enabled, you must
  45.         define the SHERLOCK symbol BEFORE including this file.
  46.  
  47.     NOTE 3:    This file uses functions prototypes from the new ANSI standard.
  48.         When older compilers, undefine HAS_ANSI_PROTOTYPES.
  49. */
  50.  
  51. #define HAS_ANSI_PROTOTYPES 1
  52.  
  53. /* Synonyms. */
  54.  
  55. #define LEAVE            TICKX
  56. #define ENTER            TICKB
  57. #define ENTER_TRACE        TRACEPB
  58.  
  59. /* Always define these. */
  60. #define SL_DISABLE()
  61. #define SL_ENABLE()
  62.  
  63. #ifdef SHERLOCK
  64.  
  65. /* Macros common to version 1 and version 2. */
  66.  
  67. #define SL_CLEAR()    sl_clear()
  68. #define SL_DUMP()    sl_dump()
  69. #define SL_INIT()    sl_init(SL_VERSION_NAME)
  70. #define SL_NAME(a,b)    static char a [] = b
  71. #define SL_OFF(s)    sl_off(s)
  72. #define SL_ON(s)    sl_on(s)
  73. #define SL_PARSE(argc,argv,on,off) sl_parse(&argc,argv,on,off)
  74.  
  75. /*
  76.     Note:    Routines that exit from a nesting level do NOT need a handle
  77.         parameter because the call_stack provides it.
  78. */
  79.  
  80. /* Make SURE that the expression is evaluated exactly once. */
  81.  
  82. #define RETURN_BOOL(a,b)    return sl_xb(a,b)
  83. #define RETURN_CHAR(a,c)    return sl_xc(a,c)
  84. #define RETURN_DOUBLE(a,d)    return sl_xd(a,d)
  85. /* Floats are passed as doubles. */
  86. #define RETURN_FLOAT(a,f)    return sl_xd(a,f)
  87. #define RETURN_INT(a,i)        return sl_xi(a,(int)i)
  88. #define RETURN_LONG(a,l)    return sl_xl(a,l)
  89. #define RETURN_PTR(a,p)        return sl_xp(a,p)
  90. #define RETURN_STRING(a,s)    return sl_xs(a,s)
  91. #define RETURN_UINT(a,ui)    return sl_xui(a,ui)
  92. #define RETURN_ULONG(a,ul)    return sl_xul(a,ul)
  93. #define RETURN_VOID(a)        {sl_xv(a); return;}
  94.  
  95. #define STATX(a)        sl_xtrace(a);    /* Ignore the return code. */
  96. #define TICKX(a)        sl_x(a)
  97. #define TICKX_BOOL(a,b)        sl_xb(a,b)
  98. #define TICKX_CHAR(a,c)        sl_xc(a,c)
  99. #define TICKX_DOUBLE(a,d)    sl_xd(a,d)
  100. #define TICKX_FLOAT(a,f)    sl_xf(a,f)
  101. #define TICKX_INT(a,i)        sl_xi(a,i)
  102. #define TICKX_LONG(a,l)        sl_xl(a,l)
  103. #define TICKX_PTR(a,p)        sl_xp(a,p)
  104. #define TICKX_STRING(a,s)    sl_xs(a,s)
  105. #define TICKX_UINT(a,u)        sl_xui(a,u)
  106. #define TICKX_ULONG(a,u)    sl_xul(a,u)
  107. #define TICKX_VOID(a)        sl_xv(a)
  108. #define TRACEX(a,b)        if(sl_xtrace(a)) {b;}
  109. #define TRACEPX(a,b)        if(sl_pxtrace(a)) {b;}
  110.  
  111. /* Macros for routines which are unique to version 1. */
  112.  
  113. #define STAT(a)        sl1stat(a)
  114. #define STATB(a)    sl1bstat(a)
  115.  
  116. #define TICK(a)        sl1tick(a)
  117. #define TICKB(a)    sl1btick(a)
  118. #define TICKN(a)    sl1ntick(a)
  119.  
  120. #define TRACE(a,b)    if(sl1trace(a)) {b;}
  121. #define TRACEB(a,b)    if(sl1btrace(a)) {b;}
  122. #define TRACEN(a,b)    if(sl1ntrace(a)) {b;}
  123.  
  124. #define TRACEP(a,b)    if(sl1ptrace(a)) {b;}
  125. #define TRACEPB(a,b)    if(sl1pbtrace(a)) {b;}
  126. #define TRACEPN(a,b)    if(sl1pntrace(a)) {b;}
  127.  
  128. /*
  129.     Function prototypes.
  130. */
  131. #ifdef HAS_ANSI_PROTOTYPES
  132.  
  133. /* Routines common to Version 1 and Version 2. */
  134.  
  135. void    sl_dump        (void);
  136. void    sl_init        (char *);
  137. void    sl_off        (char *);
  138. void    sl_on        (char *);
  139. void    sl_parse    (int *,char **,char *,char *);
  140. int    sl_pxtrace    (char *);        /* TRACEPX */
  141. void    sl_x        (char *);        /* TICKX */
  142. char     sl_xc        (char *,char);
  143. double    sl_xd        (char *,double);
  144. float    sl_xf        (char *,float);
  145. int    sl_xi        (char *,int);
  146. long    sl_xl        (char *,long);
  147. void *    sl_xp        (char *,void *);
  148. char *    sl_xs        (char *,char *);
  149. int    sl_xtrace    (char *);        /* TRACEX */
  150. unsigned int  sl_xui    (char *,unsigned int);
  151. unsigned long sl_xul    (char *,unsigned long);
  152. void    sl_xv        (char *);
  153.  
  154. void    sl_bout    (int);
  155. void    sl_cout    (char);
  156. void    sl_dout    (double);
  157. void    sl_fout    (double);    /* Floats are passed as doubles. */
  158. void    sl_iout    (int);
  159. void    sl_lout    (long);
  160. void    sl_pout (void *);
  161. char *    sl_sbout(int);
  162. void    sl_sout (char *);
  163. void    sl_uiout(unsigned int);
  164. void    sl_ulout(unsigned long);
  165.  
  166. void    sl_csout(void);
  167. void    sl_lpout(void);
  168. void    sl_rpout(void);
  169.  
  170. /* Version 1 routines. */
  171.  
  172. void    sl1bstat    (char *);
  173. void    sl1btick    (char *);
  174. int    sl1btrace    (char *);
  175. void    sl1ntick    (char *);
  176. int    sl1ntrace    (char *);
  177. int    sl1pbtrace    (char *);
  178. int    sl1pntrace    (char *);
  179. int    sl1ptrace    (char *);
  180. void    sl1stat        (char *);
  181. void    sl1tick        (char *);
  182. int    sl1trace    (char *);
  183.  
  184. #else
  185.  
  186. void    sl_dump();
  187. void    sl_init();
  188. void    sl_off();
  189. void    sl_on();
  190. void    sl_parse();
  191. int    sl_pxtrace();    /* TRACEPX */
  192. void    sl_x();        /* TICKX */
  193. char     sl_xc();
  194. double    sl_xd();
  195. float    sl_xf();
  196. int    sl_xi();
  197. long    sl_xl();
  198. void *    sl_xp();
  199. char *    sl_xs();
  200. int    sl_xtrace();    /* TRACEX */
  201. unsigned int  sl_xui();
  202. unsigned long sl_xul();
  203. void    sl_xv();
  204.  
  205. void    sl_bout();
  206. void    sl_cout();
  207. void    sl_dout();
  208. void    sl_fout();
  209. void    sl_iout();
  210. void    sl_lout();
  211. void    sl_pout();
  212. char *    sl_sbout();
  213. void    sl_sout();
  214. void    sl_uiout();
  215. void    sl_ulout();
  216.  
  217. void    sl_csout(void);
  218. void    sl_lpout(void);
  219. void    sl_rpout(void);
  220.  
  221. void    sl1bstat();
  222. void    sl1btick();
  223. int    sl1btrace();
  224. void    sl1ntick();
  225. int    sl1ntrace();
  226. int    sl1pbtrace();
  227. int    sl1pntrace();
  228. int    sl1ptrace();
  229. void    sl1stat();
  230. void    sl1tick();
  231. int    sl1trace();
  232.  
  233. #endif /* HAS_ANSI_PROTOTYPES */
  234.  
  235. #else
  236.  
  237. /*
  238.     Null macro definitions for all Sherlock macros.
  239. */
  240.  
  241. #define RETURN_BOOL(a,b)    return b
  242. #define RETURN_CHAR(a,c)    return c
  243. #define RETURN_DOUBLE(a,d)    return d
  244. #define RETURN_FLOAT(a,f)    return f
  245. #define RETURN_INT(a,i)        return i
  246. #define RETURN_LONG(a,l)    return l
  247. #define RETURN_PTR(a,p)        return p
  248. #define RETURN_STRING(a,s)    return s
  249. #define RETURN_UINT(a,u)    return u
  250. #define RETURN_ULONG(a,u)    return u
  251. #define RETURN_VOID(a)        return
  252.  
  253. #define SL_CLEAR()
  254. #define SL_DUMP()
  255. #define SL_INIT()
  256. #define SL_NAME(a,b)
  257. #define SL_OFF(s)
  258. #define SL_ON(s)
  259. #define SL_PARSE(argc,argv,on,off)
  260.  
  261. #define STAT(a)
  262. #define STATB(a)
  263. #define STATX(a)
  264.  
  265. #define TICK(a)
  266. #define TICKB(a)
  267. #define TICKN(a)
  268.  
  269. #define TICKX(a)
  270. #define TICKX_BOOL(a,b)
  271. #define TICKX_CHAR(a,c)
  272. #define TICKX_DOUBLE(a,d)
  273. #define TICKX_FLOAT(a,f)
  274. #define TICKX_INT(a,i)
  275. #define TICKX_LONG(a,l)
  276. #define TICKX_PTR(a,p)
  277. #define TICKX_STRING(a,s)
  278. #define TICKX_UINT(a,u)
  279. #define TICKX_ULONG(a,u)
  280. #define TICKX_VOID(a)
  281.  
  282. #define TRACE(a,b)
  283. #define TRACEB(a,b)
  284. #define TRACEN(a,b)
  285. #define TRACEX(a,b)
  286.  
  287. #define TRACEP(a,b)
  288. #define TRACEPB(a,b)
  289. #define TRACEPN(a,b)
  290. #define TRACEPX(a,b)
  291.  
  292. #endif /* ifdef SHERLOCK */
  293.